// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/carnot/udfspb/udfs.proto

package udfspb

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
	planpb "px.dev/pixie/src/carnot/planpb"
	typespb "px.dev/pixie/src/shared/types/typespb"
	schemapb "px.dev/pixie/src/table_store/schemapb"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type UDFSourceExecutor int32

const (
	UDF_UNSPECIFIED UDFSourceExecutor = 0
	UDF_ALL         UDFSourceExecutor = 1
	UDF_PEM         UDFSourceExecutor = 2
	UDF_KELVIN      UDFSourceExecutor = 3
)

var UDFSourceExecutor_name = map[int32]string{
	0: "UDF_UNSPECIFIED",
	1: "UDF_ALL",
	2: "UDF_PEM",
	3: "UDF_KELVIN",
}

var UDFSourceExecutor_value = map[string]int32{
	"UDF_UNSPECIFIED": 0,
	"UDF_ALL":         1,
	"UDF_PEM":         2,
	"UDF_KELVIN":      3,
}

func (UDFSourceExecutor) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{0}
}

type UDTFSourceExecutor int32

const (
	UDTF_UNSPECIFIED   UDTFSourceExecutor = 0
	UDTF_ALL_AGENTS    UDTFSourceExecutor = 1
	UDTF_ALL_PEM       UDTFSourceExecutor = 2
	UDTF_ALL_KELVIN    UDTFSourceExecutor = 3
	UDTF_SUBSET_PEM    UDTFSourceExecutor = 4
	UDTF_SUBSET_KELVIN UDTFSourceExecutor = 5
	UDTF_ONE_KELVIN    UDTFSourceExecutor = 6
)

var UDTFSourceExecutor_name = map[int32]string{
	0: "UDTF_UNSPECIFIED",
	1: "UDTF_ALL_AGENTS",
	2: "UDTF_ALL_PEM",
	3: "UDTF_ALL_KELVIN",
	4: "UDTF_SUBSET_PEM",
	5: "UDTF_SUBSET_KELVIN",
	6: "UDTF_ONE_KELVIN",
}

var UDTFSourceExecutor_value = map[string]int32{
	"UDTF_UNSPECIFIED":   0,
	"UDTF_ALL_AGENTS":    1,
	"UDTF_ALL_PEM":       2,
	"UDTF_ALL_KELVIN":    3,
	"UDTF_SUBSET_PEM":    4,
	"UDTF_SUBSET_KELVIN": 5,
	"UDTF_ONE_KELVIN":    6,
}

func (UDTFSourceExecutor) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{1}
}

type UDFExecType int32

const (
	SCALAR_UDF UDFExecType = 0
	UDA        UDFExecType = 1
)

var UDFExecType_name = map[int32]string{
	0: "SCALAR_UDF",
	1: "UDA",
}

var UDFExecType_value = map[string]int32{
	"SCALAR_UDF": 0,
	"UDA":        1,
}

func (UDFExecType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{2}
}

type UDASpec struct {
	Name            string             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	InitArgTypes    []typespb.DataType `protobuf:"varint,2,rep,packed,name=init_arg_types,json=initArgTypes,proto3,enum=px.types.DataType" json:"init_arg_types,omitempty"`
	UpdateArgTypes  []typespb.DataType `protobuf:"varint,3,rep,packed,name=update_arg_types,json=updateArgTypes,proto3,enum=px.types.DataType" json:"update_arg_types,omitempty"`
	FinalizeType    typespb.DataType   `protobuf:"varint,4,opt,name=finalize_type,json=finalizeType,proto3,enum=px.types.DataType" json:"finalize_type,omitempty"`
	SupportsPartial bool               `protobuf:"varint,5,opt,name=supports_partial,json=supportsPartial,proto3" json:"supports_partial,omitempty"`
}

func (m *UDASpec) Reset()      { *m = UDASpec{} }
func (*UDASpec) ProtoMessage() {}
func (*UDASpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{0}
}
func (m *UDASpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UDASpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UDASpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UDASpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UDASpec.Merge(m, src)
}
func (m *UDASpec) XXX_Size() int {
	return m.Size()
}
func (m *UDASpec) XXX_DiscardUnknown() {
	xxx_messageInfo_UDASpec.DiscardUnknown(m)
}

var xxx_messageInfo_UDASpec proto.InternalMessageInfo

func (m *UDASpec) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *UDASpec) GetInitArgTypes() []typespb.DataType {
	if m != nil {
		return m.InitArgTypes
	}
	return nil
}

func (m *UDASpec) GetUpdateArgTypes() []typespb.DataType {
	if m != nil {
		return m.UpdateArgTypes
	}
	return nil
}

func (m *UDASpec) GetFinalizeType() typespb.DataType {
	if m != nil {
		return m.FinalizeType
	}
	return typespb.DATA_TYPE_UNKNOWN
}

func (m *UDASpec) GetSupportsPartial() bool {
	if m != nil {
		return m.SupportsPartial
	}
	return false
}

type ScalarUDFSpec struct {
	Name         string             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	InitArgTypes []typespb.DataType `protobuf:"varint,2,rep,packed,name=init_arg_types,json=initArgTypes,proto3,enum=px.types.DataType" json:"init_arg_types,omitempty"`
	ExecArgTypes []typespb.DataType `protobuf:"varint,3,rep,packed,name=exec_arg_types,json=execArgTypes,proto3,enum=px.types.DataType" json:"exec_arg_types,omitempty"`
	ReturnType   typespb.DataType   `protobuf:"varint,4,opt,name=return_type,json=returnType,proto3,enum=px.types.DataType" json:"return_type,omitempty"`
	Executor     UDFSourceExecutor  `protobuf:"varint,5,opt,name=executor,proto3,enum=px.carnot.udfspb.UDFSourceExecutor" json:"executor,omitempty"`
}

func (m *ScalarUDFSpec) Reset()      { *m = ScalarUDFSpec{} }
func (*ScalarUDFSpec) ProtoMessage() {}
func (*ScalarUDFSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{1}
}
func (m *ScalarUDFSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ScalarUDFSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ScalarUDFSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ScalarUDFSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScalarUDFSpec.Merge(m, src)
}
func (m *ScalarUDFSpec) XXX_Size() int {
	return m.Size()
}
func (m *ScalarUDFSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ScalarUDFSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ScalarUDFSpec proto.InternalMessageInfo

func (m *ScalarUDFSpec) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ScalarUDFSpec) GetInitArgTypes() []typespb.DataType {
	if m != nil {
		return m.InitArgTypes
	}
	return nil
}

func (m *ScalarUDFSpec) GetExecArgTypes() []typespb.DataType {
	if m != nil {
		return m.ExecArgTypes
	}
	return nil
}

func (m *ScalarUDFSpec) GetReturnType() typespb.DataType {
	if m != nil {
		return m.ReturnType
	}
	return typespb.DATA_TYPE_UNKNOWN
}

func (m *ScalarUDFSpec) GetExecutor() UDFSourceExecutor {
	if m != nil {
		return m.Executor
	}
	return UDF_UNSPECIFIED
}

type UDFInfo struct {
	Udas              []*UDASpec               `protobuf:"bytes,1,rep,name=udas,proto3" json:"udas,omitempty"`
	ScalarUdfs        []*ScalarUDFSpec         `protobuf:"bytes,2,rep,name=scalar_udfs,json=scalarUdfs,proto3" json:"scalar_udfs,omitempty"`
	Udtfs             []*UDTFSourceSpec        `protobuf:"bytes,3,rep,name=udtfs,proto3" json:"udtfs,omitempty"`
	SemanticTypeRules []*SemanticInferenceRule `protobuf:"bytes,4,rep,name=semantic_type_rules,json=semanticTypeRules,proto3" json:"semantic_type_rules,omitempty"`
}

func (m *UDFInfo) Reset()      { *m = UDFInfo{} }
func (*UDFInfo) ProtoMessage() {}
func (*UDFInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{2}
}
func (m *UDFInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UDFInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UDFInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UDFInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UDFInfo.Merge(m, src)
}
func (m *UDFInfo) XXX_Size() int {
	return m.Size()
}
func (m *UDFInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_UDFInfo.DiscardUnknown(m)
}

var xxx_messageInfo_UDFInfo proto.InternalMessageInfo

func (m *UDFInfo) GetUdas() []*UDASpec {
	if m != nil {
		return m.Udas
	}
	return nil
}

func (m *UDFInfo) GetScalarUdfs() []*ScalarUDFSpec {
	if m != nil {
		return m.ScalarUdfs
	}
	return nil
}

func (m *UDFInfo) GetUdtfs() []*UDTFSourceSpec {
	if m != nil {
		return m.Udtfs
	}
	return nil
}

func (m *UDFInfo) GetSemanticTypeRules() []*SemanticInferenceRule {
	if m != nil {
		return m.SemanticTypeRules
	}
	return nil
}

type UDTFSourceSpec struct {
	Name     string                `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Args     []*UDTFSourceSpec_Arg `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
	Executor UDTFSourceExecutor    `protobuf:"varint,3,opt,name=executor,proto3,enum=px.carnot.udfspb.UDTFSourceExecutor" json:"executor,omitempty"`
	Relation *schemapb.Relation    `protobuf:"bytes,4,opt,name=relation,proto3" json:"relation,omitempty"`
}

func (m *UDTFSourceSpec) Reset()      { *m = UDTFSourceSpec{} }
func (*UDTFSourceSpec) ProtoMessage() {}
func (*UDTFSourceSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{3}
}
func (m *UDTFSourceSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UDTFSourceSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UDTFSourceSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UDTFSourceSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UDTFSourceSpec.Merge(m, src)
}
func (m *UDTFSourceSpec) XXX_Size() int {
	return m.Size()
}
func (m *UDTFSourceSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_UDTFSourceSpec.DiscardUnknown(m)
}

var xxx_messageInfo_UDTFSourceSpec proto.InternalMessageInfo

func (m *UDTFSourceSpec) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *UDTFSourceSpec) GetArgs() []*UDTFSourceSpec_Arg {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *UDTFSourceSpec) GetExecutor() UDTFSourceExecutor {
	if m != nil {
		return m.Executor
	}
	return UDTF_UNSPECIFIED
}

func (m *UDTFSourceSpec) GetRelation() *schemapb.Relation {
	if m != nil {
		return m.Relation
	}
	return nil
}

type UDTFSourceSpec_Arg struct {
	Name         string               `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ArgType      typespb.DataType     `protobuf:"varint,2,opt,name=arg_type,json=argType,proto3,enum=px.types.DataType" json:"arg_type,omitempty"`
	SemanticType typespb.SemanticType `protobuf:"varint,3,opt,name=semantic_type,json=semanticType,proto3,enum=px.types.SemanticType" json:"semantic_type,omitempty"`
	DefaultValue *planpb.ScalarValue  `protobuf:"bytes,4,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
}

func (m *UDTFSourceSpec_Arg) Reset()      { *m = UDTFSourceSpec_Arg{} }
func (*UDTFSourceSpec_Arg) ProtoMessage() {}
func (*UDTFSourceSpec_Arg) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{3, 0}
}
func (m *UDTFSourceSpec_Arg) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UDTFSourceSpec_Arg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UDTFSourceSpec_Arg.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UDTFSourceSpec_Arg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UDTFSourceSpec_Arg.Merge(m, src)
}
func (m *UDTFSourceSpec_Arg) XXX_Size() int {
	return m.Size()
}
func (m *UDTFSourceSpec_Arg) XXX_DiscardUnknown() {
	xxx_messageInfo_UDTFSourceSpec_Arg.DiscardUnknown(m)
}

var xxx_messageInfo_UDTFSourceSpec_Arg proto.InternalMessageInfo

func (m *UDTFSourceSpec_Arg) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *UDTFSourceSpec_Arg) GetArgType() typespb.DataType {
	if m != nil {
		return m.ArgType
	}
	return typespb.DATA_TYPE_UNKNOWN
}

func (m *UDTFSourceSpec_Arg) GetSemanticType() typespb.SemanticType {
	if m != nil {
		return m.SemanticType
	}
	return typespb.ST_UNSPECIFIED
}

func (m *UDTFSourceSpec_Arg) GetDefaultValue() *planpb.ScalarValue {
	if m != nil {
		return m.DefaultValue
	}
	return nil
}

type SemanticInferenceRule struct {
	Name           string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	UdfExecType    UDFExecType            `protobuf:"varint,2,opt,name=udf_exec_type,json=udfExecType,proto3,enum=px.carnot.udfspb.UDFExecType" json:"udf_exec_type,omitempty"`
	InitArgTypes   []typespb.SemanticType `protobuf:"varint,3,rep,packed,name=init_arg_types,json=initArgTypes,proto3,enum=px.types.SemanticType" json:"init_arg_types,omitempty"`
	UpdateArgTypes []typespb.SemanticType `protobuf:"varint,4,rep,packed,name=update_arg_types,json=updateArgTypes,proto3,enum=px.types.SemanticType" json:"update_arg_types,omitempty"`
	ExecArgTypes   []typespb.SemanticType `protobuf:"varint,5,rep,packed,name=exec_arg_types,json=execArgTypes,proto3,enum=px.types.SemanticType" json:"exec_arg_types,omitempty"`
	OutputType     typespb.SemanticType   `protobuf:"varint,6,opt,name=output_type,json=outputType,proto3,enum=px.types.SemanticType" json:"output_type,omitempty"`
}

func (m *SemanticInferenceRule) Reset()      { *m = SemanticInferenceRule{} }
func (*SemanticInferenceRule) ProtoMessage() {}
func (*SemanticInferenceRule) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{4}
}
func (m *SemanticInferenceRule) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SemanticInferenceRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SemanticInferenceRule.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SemanticInferenceRule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SemanticInferenceRule.Merge(m, src)
}
func (m *SemanticInferenceRule) XXX_Size() int {
	return m.Size()
}
func (m *SemanticInferenceRule) XXX_DiscardUnknown() {
	xxx_messageInfo_SemanticInferenceRule.DiscardUnknown(m)
}

var xxx_messageInfo_SemanticInferenceRule proto.InternalMessageInfo

func (m *SemanticInferenceRule) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *SemanticInferenceRule) GetUdfExecType() UDFExecType {
	if m != nil {
		return m.UdfExecType
	}
	return SCALAR_UDF
}

func (m *SemanticInferenceRule) GetInitArgTypes() []typespb.SemanticType {
	if m != nil {
		return m.InitArgTypes
	}
	return nil
}

func (m *SemanticInferenceRule) GetUpdateArgTypes() []typespb.SemanticType {
	if m != nil {
		return m.UpdateArgTypes
	}
	return nil
}

func (m *SemanticInferenceRule) GetExecArgTypes() []typespb.SemanticType {
	if m != nil {
		return m.ExecArgTypes
	}
	return nil
}

func (m *SemanticInferenceRule) GetOutputType() typespb.SemanticType {
	if m != nil {
		return m.OutputType
	}
	return typespb.ST_UNSPECIFIED
}

type IdentDoc struct {
	Ident string           `protobuf:"bytes,1,opt,name=ident,proto3" json:"ident,omitempty"`
	Desc  string           `protobuf:"bytes,2,opt,name=desc,proto3" json:"desc,omitempty"`
	Type  typespb.DataType `protobuf:"varint,3,opt,name=type,proto3,enum=px.types.DataType" json:"type,omitempty"`
}

func (m *IdentDoc) Reset()      { *m = IdentDoc{} }
func (*IdentDoc) ProtoMessage() {}
func (*IdentDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{5}
}
func (m *IdentDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IdentDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IdentDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IdentDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IdentDoc.Merge(m, src)
}
func (m *IdentDoc) XXX_Size() int {
	return m.Size()
}
func (m *IdentDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_IdentDoc.DiscardUnknown(m)
}

var xxx_messageInfo_IdentDoc proto.InternalMessageInfo

func (m *IdentDoc) GetIdent() string {
	if m != nil {
		return m.Ident
	}
	return ""
}

func (m *IdentDoc) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

func (m *IdentDoc) GetType() typespb.DataType {
	if m != nil {
		return m.Type
	}
	return typespb.DATA_TYPE_UNKNOWN
}

type ScalarDoc struct {
	Args   []*IdentDoc `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"`
	Retval *IdentDoc   `protobuf:"bytes,2,opt,name=retval,proto3" json:"retval,omitempty"`
}

func (m *ScalarDoc) Reset()      { *m = ScalarDoc{} }
func (*ScalarDoc) ProtoMessage() {}
func (*ScalarDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{6}
}
func (m *ScalarDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ScalarDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ScalarDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ScalarDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScalarDoc.Merge(m, src)
}
func (m *ScalarDoc) XXX_Size() int {
	return m.Size()
}
func (m *ScalarDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_ScalarDoc.DiscardUnknown(m)
}

var xxx_messageInfo_ScalarDoc proto.InternalMessageInfo

func (m *ScalarDoc) GetArgs() []*IdentDoc {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *ScalarDoc) GetRetval() *IdentDoc {
	if m != nil {
		return m.Retval
	}
	return nil
}

type ExampleDoc struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *ExampleDoc) Reset()      { *m = ExampleDoc{} }
func (*ExampleDoc) ProtoMessage() {}
func (*ExampleDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{7}
}
func (m *ExampleDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExampleDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExampleDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExampleDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExampleDoc.Merge(m, src)
}
func (m *ExampleDoc) XXX_Size() int {
	return m.Size()
}
func (m *ExampleDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_ExampleDoc.DiscardUnknown(m)
}

var xxx_messageInfo_ExampleDoc proto.InternalMessageInfo

func (m *ExampleDoc) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type UDADoc struct {
	UpdateArgs []*IdentDoc `protobuf:"bytes,1,rep,name=update_args,json=updateArgs,proto3" json:"update_args,omitempty"`
	Result     *IdentDoc   `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
}

func (m *UDADoc) Reset()      { *m = UDADoc{} }
func (*UDADoc) ProtoMessage() {}
func (*UDADoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{8}
}
func (m *UDADoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UDADoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UDADoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UDADoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UDADoc.Merge(m, src)
}
func (m *UDADoc) XXX_Size() int {
	return m.Size()
}
func (m *UDADoc) XXX_DiscardUnknown() {
	xxx_messageInfo_UDADoc.DiscardUnknown(m)
}

var xxx_messageInfo_UDADoc proto.InternalMessageInfo

func (m *UDADoc) GetUpdateArgs() []*IdentDoc {
	if m != nil {
		return m.UpdateArgs
	}
	return nil
}

func (m *UDADoc) GetResult() *IdentDoc {
	if m != nil {
		return m.Result
	}
	return nil
}

type Doc struct {
	Name     string        `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Brief    string        `protobuf:"bytes,2,opt,name=brief,proto3" json:"brief,omitempty"`
	Desc     string        `protobuf:"bytes,3,opt,name=desc,proto3" json:"desc,omitempty"`
	Examples []*ExampleDoc `protobuf:"bytes,4,rep,name=examples,proto3" json:"examples,omitempty"`
	// Types that are valid to be assigned to U:
	//	*Doc_ScalarUdfDoc
	//	*Doc_UdaDoc
	U isDoc_U `protobuf_oneof:"u"`
}

func (m *Doc) Reset()      { *m = Doc{} }
func (*Doc) ProtoMessage() {}
func (*Doc) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{9}
}
func (m *Doc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Doc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Doc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Doc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Doc.Merge(m, src)
}
func (m *Doc) XXX_Size() int {
	return m.Size()
}
func (m *Doc) XXX_DiscardUnknown() {
	xxx_messageInfo_Doc.DiscardUnknown(m)
}

var xxx_messageInfo_Doc proto.InternalMessageInfo

type isDoc_U interface {
	isDoc_U()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Doc_ScalarUdfDoc struct {
	ScalarUdfDoc *ScalarDoc `protobuf:"bytes,5,opt,name=scalar_udf_doc,json=scalarUdfDoc,proto3,oneof" json:"scalar_udf_doc,omitempty"`
}
type Doc_UdaDoc struct {
	UdaDoc *UDADoc `protobuf:"bytes,6,opt,name=uda_doc,json=udaDoc,proto3,oneof" json:"uda_doc,omitempty"`
}

func (*Doc_ScalarUdfDoc) isDoc_U() {}
func (*Doc_UdaDoc) isDoc_U()       {}

func (m *Doc) GetU() isDoc_U {
	if m != nil {
		return m.U
	}
	return nil
}

func (m *Doc) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Doc) GetBrief() string {
	if m != nil {
		return m.Brief
	}
	return ""
}

func (m *Doc) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

func (m *Doc) GetExamples() []*ExampleDoc {
	if m != nil {
		return m.Examples
	}
	return nil
}

func (m *Doc) GetScalarUdfDoc() *ScalarDoc {
	if x, ok := m.GetU().(*Doc_ScalarUdfDoc); ok {
		return x.ScalarUdfDoc
	}
	return nil
}

func (m *Doc) GetUdaDoc() *UDADoc {
	if x, ok := m.GetU().(*Doc_UdaDoc); ok {
		return x.UdaDoc
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Doc) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Doc_ScalarUdfDoc)(nil),
		(*Doc_UdaDoc)(nil),
	}
}

type Docs struct {
	Udf []*Doc `protobuf:"bytes,1,rep,name=udf,proto3" json:"udf,omitempty"`
}

func (m *Docs) Reset()      { *m = Docs{} }
func (*Docs) ProtoMessage() {}
func (*Docs) Descriptor() ([]byte, []int) {
	return fileDescriptor_870a8b723557d52e, []int{10}
}
func (m *Docs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Docs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Docs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Docs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Docs.Merge(m, src)
}
func (m *Docs) XXX_Size() int {
	return m.Size()
}
func (m *Docs) XXX_DiscardUnknown() {
	xxx_messageInfo_Docs.DiscardUnknown(m)
}

var xxx_messageInfo_Docs proto.InternalMessageInfo

func (m *Docs) GetUdf() []*Doc {
	if m != nil {
		return m.Udf
	}
	return nil
}

func init() {
	proto.RegisterEnum("px.carnot.udfspb.UDFSourceExecutor", UDFSourceExecutor_name, UDFSourceExecutor_value)
	proto.RegisterEnum("px.carnot.udfspb.UDTFSourceExecutor", UDTFSourceExecutor_name, UDTFSourceExecutor_value)
	proto.RegisterEnum("px.carnot.udfspb.UDFExecType", UDFExecType_name, UDFExecType_value)
	proto.RegisterType((*UDASpec)(nil), "px.carnot.udfspb.UDASpec")
	proto.RegisterType((*ScalarUDFSpec)(nil), "px.carnot.udfspb.ScalarUDFSpec")
	proto.RegisterType((*UDFInfo)(nil), "px.carnot.udfspb.UDFInfo")
	proto.RegisterType((*UDTFSourceSpec)(nil), "px.carnot.udfspb.UDTFSourceSpec")
	proto.RegisterType((*UDTFSourceSpec_Arg)(nil), "px.carnot.udfspb.UDTFSourceSpec.Arg")
	proto.RegisterType((*SemanticInferenceRule)(nil), "px.carnot.udfspb.SemanticInferenceRule")
	proto.RegisterType((*IdentDoc)(nil), "px.carnot.udfspb.IdentDoc")
	proto.RegisterType((*ScalarDoc)(nil), "px.carnot.udfspb.ScalarDoc")
	proto.RegisterType((*ExampleDoc)(nil), "px.carnot.udfspb.ExampleDoc")
	proto.RegisterType((*UDADoc)(nil), "px.carnot.udfspb.UDADoc")
	proto.RegisterType((*Doc)(nil), "px.carnot.udfspb.Doc")
	proto.RegisterType((*Docs)(nil), "px.carnot.udfspb.Docs")
}

func init() { proto.RegisterFile("src/carnot/udfspb/udfs.proto", fileDescriptor_870a8b723557d52e) }

var fileDescriptor_870a8b723557d52e = []byte{
	// 1125 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xdf, 0x4f, 0xdb, 0xd6,
	0x17, 0x8f, 0xe3, 0x24, 0xc0, 0x71, 0x48, 0xdd, 0x5b, 0x5a, 0xe5, 0xcb, 0xb7, 0xf5, 0x32, 0xaf,
	0x6b, 0x19, 0x52, 0x83, 0x14, 0xa4, 0x15, 0xa9, 0x4c, 0x23, 0xe0, 0xb0, 0x45, 0x63, 0x0c, 0x39,
	0xa4, 0x93, 0xa6, 0x49, 0xd6, 0x8d, 0x7d, 0x43, 0x23, 0x19, 0xdb, 0xba, 0xb6, 0x2b, 0xd8, 0xd3,
	0xde, 0xa7, 0x49, 0xfb, 0x33, 0x2a, 0xed, 0x1f, 0xd9, 0xde, 0x78, 0xec, 0xe3, 0x08, 0x9a, 0xb4,
	0xc7, 0xbe, 0x4e, 0xda, 0xc3, 0x74, 0xef, 0xb5, 0x83, 0x21, 0x0e, 0xe5, 0x65, 0x2f, 0xe4, 0xfe,
	0xf8, 0x7c, 0xce, 0x8f, 0xcf, 0x39, 0xf7, 0x18, 0x78, 0x18, 0x52, 0x7b, 0xcd, 0xc6, 0xd4, 0xf3,
	0xa3, 0xb5, 0xd8, 0x19, 0x86, 0xc1, 0x80, 0xff, 0x34, 0x03, 0xea, 0x47, 0x3e, 0x52, 0x83, 0x93,
	0xa6, 0xb8, 0x6c, 0x8a, 0xcb, 0xe5, 0x2c, 0x3e, 0x70, 0xb1, 0x17, 0x0c, 0xf8, 0x8f, 0xc0, 0x2f,
	0x3f, 0x66, 0xb7, 0xe1, 0x2b, 0x4c, 0x89, 0xb3, 0x16, 0x9d, 0x06, 0x24, 0x14, 0x7f, 0x83, 0x81,
	0xf8, 0x4d, 0x50, 0x1f, 0x33, 0x54, 0x84, 0x07, 0x2e, 0xb1, 0xc2, 0xc8, 0xa7, 0x64, 0x2d, 0xb4,
	0x5f, 0x91, 0x63, 0x1c, 0x0c, 0x92, 0x85, 0x80, 0xe9, 0x7f, 0x4b, 0x30, 0xd7, 0x37, 0xda, 0xbd,
	0x80, 0xd8, 0x08, 0x41, 0xc9, 0xc3, 0xc7, 0xa4, 0x2e, 0x35, 0xa4, 0x95, 0x05, 0x93, 0xaf, 0xd1,
	0x06, 0xd4, 0x46, 0xde, 0x28, 0xb2, 0x30, 0x3d, 0xb2, 0xb8, 0xf9, 0x7a, 0xb1, 0x21, 0xaf, 0xd4,
	0x5a, 0xa8, 0x19, 0x9c, 0x34, 0x85, 0x3f, 0x03, 0x47, 0xf8, 0xf0, 0x34, 0x20, 0x66, 0x95, 0x21,
	0xdb, 0xf4, 0x88, 0x6d, 0x42, 0xb4, 0x09, 0x6a, 0x1c, 0x38, 0x38, 0x22, 0x19, 0xae, 0x3c, 0x93,
	0x5b, 0x13, 0xd8, 0x09, 0xfb, 0x39, 0x2c, 0x0e, 0x47, 0x1e, 0x76, 0x47, 0x3f, 0x10, 0xce, 0xad,
	0x97, 0x1a, 0xd2, 0x2c, 0xb7, 0x29, 0x90, 0xed, 0xd0, 0x27, 0xa0, 0x86, 0x71, 0x10, 0xf8, 0x34,
	0x0a, 0xad, 0x00, 0xd3, 0x68, 0x84, 0xdd, 0x7a, 0xb9, 0x21, 0xad, 0xcc, 0x9b, 0x77, 0xd2, 0xf3,
	0x03, 0x71, 0xac, 0xff, 0x5c, 0x84, 0xc5, 0x9e, 0x8d, 0x5d, 0x4c, 0xfb, 0xc6, 0xee, 0x7f, 0xa0,
	0xc0, 0x06, 0xd4, 0xc8, 0x09, 0xb1, 0x6f, 0x95, 0x7f, 0x95, 0x21, 0x27, 0xcc, 0x75, 0x50, 0x28,
	0x89, 0x62, 0xea, 0xbd, 0x2f, 0x77, 0x10, 0x30, 0x9e, 0xf9, 0xe7, 0x30, 0xcf, 0x8c, 0xc4, 0x91,
	0x4f, 0x79, 0xc6, 0xb5, 0xd6, 0x47, 0xcd, 0xeb, 0xad, 0xd5, 0x64, 0x99, 0xfa, 0x31, 0xb5, 0x49,
	0x27, 0x81, 0x9a, 0x13, 0x92, 0xfe, 0x53, 0x91, 0xf5, 0xc2, 0x6e, 0xd7, 0x1b, 0xfa, 0xe8, 0x19,
	0x94, 0x62, 0x07, 0x87, 0x75, 0xa9, 0x21, 0xaf, 0x28, 0xad, 0xff, 0xe5, 0x19, 0xe2, 0x4d, 0x63,
	0x72, 0x18, 0xda, 0x02, 0x25, 0xe4, 0x4a, 0x5a, 0xec, 0x9a, 0x2b, 0xa4, 0xb4, 0x3e, 0x98, 0x66,
	0x5d, 0x91, 0xdb, 0x04, 0xc1, 0xe9, 0x3b, 0xc3, 0x10, 0x7d, 0x0a, 0xe5, 0xd8, 0x89, 0x86, 0x42,
	0x23, 0xa5, 0xd5, 0xc8, 0xf3, 0x78, 0x98, 0xc4, 0xce, 0xc9, 0x02, 0x8e, 0xbe, 0x85, 0x7b, 0x21,
	0x39, 0xc6, 0x5e, 0x34, 0xb2, 0xb9, 0x58, 0x16, 0x8d, 0x5d, 0x12, 0xd6, 0x4b, 0xdc, 0xca, 0xd3,
	0x9c, 0x08, 0x12, 0x70, 0xd7, 0x1b, 0x12, 0x4a, 0x3c, 0x9b, 0x98, 0xb1, 0x4b, 0xcc, 0xbb, 0xa9,
	0x0d, 0xae, 0x2a, 0xb3, 0xa0, 0xff, 0x2a, 0x43, 0xed, 0xaa, 0xcb, 0x19, 0xed, 0x51, 0xc2, 0xf4,
	0x28, 0x4d, 0xf9, 0xf1, 0xfb, 0xc2, 0x6e, 0xb6, 0xe9, 0x91, 0xc9, 0x19, 0x68, 0x2b, 0x53, 0x2f,
	0x99, 0xd7, 0xeb, 0x46, 0xf6, 0x74, 0xc1, 0xd0, 0x67, 0x30, 0x4f, 0x89, 0x8b, 0xa3, 0x91, 0xef,
	0xf1, 0x1e, 0x51, 0x5a, 0x1f, 0xf2, 0x1e, 0xb9, 0x7c, 0xf5, 0xcd, 0xf4, 0xd5, 0x37, 0xcd, 0x04,
	0x68, 0x4e, 0x28, 0xcb, 0xbf, 0x4b, 0x20, 0xb7, 0xe9, 0x51, 0x6e, 0x5a, 0xcf, 0x60, 0x3e, 0x6d,
	0xdb, 0x7a, 0x71, 0x66, 0xfb, 0xcd, 0x61, 0xd1, 0xb1, 0xe8, 0x05, 0x2c, 0x5e, 0xa9, 0x42, 0x92,
	0xd0, 0x83, 0x4b, 0x4e, 0x2f, 0x2b, 0x70, 0x35, 0x2b, 0x37, 0xda, 0x86, 0x45, 0x87, 0x0c, 0x71,
	0xec, 0x46, 0xd6, 0x6b, 0xec, 0xc6, 0x24, 0xc9, 0xe5, 0x51, 0x46, 0x0d, 0x31, 0x05, 0x93, 0xf6,
	0x79, 0xc9, 0x40, 0x66, 0x35, 0xe1, 0xf0, 0x9d, 0xfe, 0x67, 0x11, 0xee, 0xe7, 0x96, 0x36, 0x37,
	0xbb, 0x36, 0x2c, 0xc6, 0xce, 0xd0, 0xe2, 0xaf, 0x33, 0x93, 0xe2, 0xa3, 0xdc, 0xf7, 0xc2, 0x84,
	0xe7, 0x51, 0x2b, 0xb1, 0x33, 0x4c, 0x37, 0x68, 0x73, 0x6a, 0x2c, 0x88, 0xc7, 0x3d, 0x33, 0xe5,
	0x2b, 0xa3, 0x61, 0x2b, 0x67, 0x38, 0x96, 0x6e, 0xe4, 0x5f, 0x1f, 0x90, 0x9b, 0x53, 0xc3, 0xa5,
	0x7c, 0xb3, 0xff, 0x2b, 0x03, 0xe6, 0x39, 0x28, 0x7e, 0x1c, 0x05, 0x71, 0x24, 0xd2, 0xaf, 0xdc,
	0x58, 0x2d, 0x10, 0x50, 0xb6, 0xd6, 0xbf, 0x87, 0xf9, 0xae, 0x43, 0xbc, 0xc8, 0xf0, 0x6d, 0xb4,
	0x04, 0xe5, 0x11, 0x5b, 0x27, 0xd2, 0x8a, 0x0d, 0xd3, 0xdb, 0x21, 0xa1, 0xcd, 0x25, 0x5d, 0x30,
	0xf9, 0x1a, 0x3d, 0x81, 0x52, 0xa6, 0x2b, 0xf2, 0x3a, 0x89, 0xdf, 0xeb, 0x3e, 0x2c, 0x88, 0x12,
	0x33, 0xf3, 0xcd, 0xe4, 0x65, 0x89, 0x11, 0xb4, 0x3c, 0x5d, 0x9b, 0x34, 0x90, 0xe4, 0x3d, 0xb5,
	0xa0, 0x42, 0x49, 0xf4, 0x1a, 0xbb, 0xdc, 0xf5, 0xcd, 0x8c, 0x04, 0xa9, 0xeb, 0x00, 0x9d, 0x13,
	0x7c, 0x1c, 0xb8, 0x24, 0x49, 0x48, 0x34, 0x60, 0x92, 0x10, 0xdf, 0xe8, 0xa7, 0x50, 0xe9, 0x1b,
	0x6d, 0x76, 0xff, 0x02, 0x94, 0xcb, 0xaa, 0xdd, 0x26, 0x30, 0x98, 0x14, 0x2d, 0x09, 0x2f, 0x8c,
	0xdd, 0xe8, 0x76, 0xe1, 0x31, 0xa4, 0xfe, 0x8f, 0x04, 0x32, 0x73, 0x9c, 0xd7, 0xc3, 0x4b, 0x50,
	0x1e, 0xd0, 0x11, 0x19, 0x26, 0x42, 0x8b, 0xcd, 0x44, 0x7d, 0x39, 0xa3, 0xfe, 0x06, 0x1b, 0x34,
	0x3c, 0xc9, 0x74, 0x2e, 0x3e, 0x9c, 0xf6, 0x7d, 0x29, 0x83, 0x39, 0x41, 0xa3, 0x1d, 0xa8, 0x5d,
	0x8e, 0x75, 0xcb, 0xf1, 0x6d, 0xfe, 0x61, 0x51, 0x5a, 0xff, 0x9f, 0x35, 0xd9, 0x0d, 0xdf, 0xfe,
	0xb2, 0x60, 0x56, 0x27, 0x73, 0x9d, 0x05, 0xbf, 0x0e, 0x73, 0xb1, 0x83, 0x39, 0xbb, 0xc2, 0xd9,
	0xf5, 0xdc, 0xaf, 0x89, 0xa0, 0x56, 0x62, 0x07, 0x1b, 0xbe, 0xbd, 0x2d, 0x83, 0x14, 0xeb, 0x6b,
	0x50, 0x32, 0x7c, 0x3b, 0x44, 0x4f, 0x41, 0x8e, 0x9d, 0x61, 0xa2, 0xf7, 0xfd, 0x69, 0x36, 0x0b,
	0x9a, 0x21, 0x56, 0x4d, 0xb8, 0x3b, 0xf5, 0x81, 0x43, 0xf7, 0xe0, 0x4e, 0xdf, 0xd8, 0xb5, 0xfa,
	0xfb, 0xbd, 0x83, 0xce, 0x4e, 0x77, 0xb7, 0xdb, 0x31, 0xd4, 0x02, 0x52, 0xf8, 0xa7, 0xce, 0x6a,
	0xef, 0xed, 0xa9, 0x52, 0xba, 0x39, 0xe8, 0x7c, 0xad, 0x16, 0x51, 0x0d, 0x80, 0x6d, 0xbe, 0xea,
	0xec, 0xbd, 0xec, 0xee, 0xab, 0xf2, 0xea, 0x1b, 0x09, 0xd0, 0xf4, 0x14, 0x46, 0x4b, 0xa0, 0xb2,
	0xd3, 0x6b, 0x66, 0xb9, 0xaf, 0x43, 0x6e, 0xd7, 0x6a, 0x7f, 0xd1, 0xd9, 0x3f, 0xec, 0xa9, 0x12,
	0x52, 0xa1, 0x3a, 0x39, 0x14, 0x3e, 0xb2, 0xb0, 0xd4, 0xd1, 0xe4, 0xb0, 0xd7, 0xdf, 0xee, 0x75,
	0x0e, 0x39, 0xb2, 0x84, 0x1e, 0x08, 0xe7, 0xe9, 0x61, 0x02, 0x2e, 0x4f, 0xc0, 0xdf, 0xec, 0x77,
	0xd2, 0xc3, 0xca, 0xea, 0x13, 0x50, 0x32, 0xf3, 0x8a, 0x65, 0xd2, 0xdb, 0x69, 0xef, 0xb5, 0x4d,
	0xab, 0x6f, 0xec, 0xaa, 0x05, 0x34, 0x07, 0x72, 0xdf, 0x68, 0xab, 0xd2, 0xf6, 0xe6, 0xd9, 0xb9,
	0x56, 0x78, 0x7b, 0xae, 0x15, 0xde, 0x9d, 0x6b, 0xd2, 0x8f, 0x63, 0x4d, 0x7a, 0x33, 0xd6, 0xa4,
	0xdf, 0xc6, 0x9a, 0x74, 0x36, 0xd6, 0xa4, 0x3f, 0xc6, 0x9a, 0xf4, 0xd7, 0x58, 0x2b, 0xbc, 0x1b,
	0x6b, 0xd2, 0x2f, 0x17, 0x5a, 0xe1, 0xec, 0x42, 0x2b, 0xbc, 0xbd, 0xd0, 0x0a, 0xdf, 0x55, 0x84,
	0xda, 0x83, 0x0a, 0xff, 0xcf, 0x71, 0xfd, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xae, 0xa3, 0x04,
	0x53, 0xd6, 0x0a, 0x00, 0x00,
}

func (x UDFSourceExecutor) String() string {
	s, ok := UDFSourceExecutor_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x UDTFSourceExecutor) String() string {
	s, ok := UDTFSourceExecutor_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x UDFExecType) String() string {
	s, ok := UDFExecType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *UDASpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UDASpec)
	if !ok {
		that2, ok := that.(UDASpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if len(this.InitArgTypes) != len(that1.InitArgTypes) {
		return false
	}
	for i := range this.InitArgTypes {
		if this.InitArgTypes[i] != that1.InitArgTypes[i] {
			return false
		}
	}
	if len(this.UpdateArgTypes) != len(that1.UpdateArgTypes) {
		return false
	}
	for i := range this.UpdateArgTypes {
		if this.UpdateArgTypes[i] != that1.UpdateArgTypes[i] {
			return false
		}
	}
	if this.FinalizeType != that1.FinalizeType {
		return false
	}
	if this.SupportsPartial != that1.SupportsPartial {
		return false
	}
	return true
}
func (this *ScalarUDFSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ScalarUDFSpec)
	if !ok {
		that2, ok := that.(ScalarUDFSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if len(this.InitArgTypes) != len(that1.InitArgTypes) {
		return false
	}
	for i := range this.InitArgTypes {
		if this.InitArgTypes[i] != that1.InitArgTypes[i] {
			return false
		}
	}
	if len(this.ExecArgTypes) != len(that1.ExecArgTypes) {
		return false
	}
	for i := range this.ExecArgTypes {
		if this.ExecArgTypes[i] != that1.ExecArgTypes[i] {
			return false
		}
	}
	if this.ReturnType != that1.ReturnType {
		return false
	}
	if this.Executor != that1.Executor {
		return false
	}
	return true
}
func (this *UDFInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UDFInfo)
	if !ok {
		that2, ok := that.(UDFInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Udas) != len(that1.Udas) {
		return false
	}
	for i := range this.Udas {
		if !this.Udas[i].Equal(that1.Udas[i]) {
			return false
		}
	}
	if len(this.ScalarUdfs) != len(that1.ScalarUdfs) {
		return false
	}
	for i := range this.ScalarUdfs {
		if !this.ScalarUdfs[i].Equal(that1.ScalarUdfs[i]) {
			return false
		}
	}
	if len(this.Udtfs) != len(that1.Udtfs) {
		return false
	}
	for i := range this.Udtfs {
		if !this.Udtfs[i].Equal(that1.Udtfs[i]) {
			return false
		}
	}
	if len(this.SemanticTypeRules) != len(that1.SemanticTypeRules) {
		return false
	}
	for i := range this.SemanticTypeRules {
		if !this.SemanticTypeRules[i].Equal(that1.SemanticTypeRules[i]) {
			return false
		}
	}
	return true
}
func (this *UDTFSourceSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UDTFSourceSpec)
	if !ok {
		that2, ok := that.(UDTFSourceSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if len(this.Args) != len(that1.Args) {
		return false
	}
	for i := range this.Args {
		if !this.Args[i].Equal(that1.Args[i]) {
			return false
		}
	}
	if this.Executor != that1.Executor {
		return false
	}
	if !this.Relation.Equal(that1.Relation) {
		return false
	}
	return true
}
func (this *UDTFSourceSpec_Arg) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UDTFSourceSpec_Arg)
	if !ok {
		that2, ok := that.(UDTFSourceSpec_Arg)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ArgType != that1.ArgType {
		return false
	}
	if this.SemanticType != that1.SemanticType {
		return false
	}
	if !this.DefaultValue.Equal(that1.DefaultValue) {
		return false
	}
	return true
}
func (this *SemanticInferenceRule) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SemanticInferenceRule)
	if !ok {
		that2, ok := that.(SemanticInferenceRule)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.UdfExecType != that1.UdfExecType {
		return false
	}
	if len(this.InitArgTypes) != len(that1.InitArgTypes) {
		return false
	}
	for i := range this.InitArgTypes {
		if this.InitArgTypes[i] != that1.InitArgTypes[i] {
			return false
		}
	}
	if len(this.UpdateArgTypes) != len(that1.UpdateArgTypes) {
		return false
	}
	for i := range this.UpdateArgTypes {
		if this.UpdateArgTypes[i] != that1.UpdateArgTypes[i] {
			return false
		}
	}
	if len(this.ExecArgTypes) != len(that1.ExecArgTypes) {
		return false
	}
	for i := range this.ExecArgTypes {
		if this.ExecArgTypes[i] != that1.ExecArgTypes[i] {
			return false
		}
	}
	if this.OutputType != that1.OutputType {
		return false
	}
	return true
}
func (this *IdentDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IdentDoc)
	if !ok {
		that2, ok := that.(IdentDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Ident != that1.Ident {
		return false
	}
	if this.Desc != that1.Desc {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	return true
}
func (this *ScalarDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ScalarDoc)
	if !ok {
		that2, ok := that.(ScalarDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Args) != len(that1.Args) {
		return false
	}
	for i := range this.Args {
		if !this.Args[i].Equal(that1.Args[i]) {
			return false
		}
	}
	if !this.Retval.Equal(that1.Retval) {
		return false
	}
	return true
}
func (this *ExampleDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExampleDoc)
	if !ok {
		that2, ok := that.(ExampleDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	return true
}
func (this *UDADoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UDADoc)
	if !ok {
		that2, ok := that.(UDADoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.UpdateArgs) != len(that1.UpdateArgs) {
		return false
	}
	for i := range this.UpdateArgs {
		if !this.UpdateArgs[i].Equal(that1.UpdateArgs[i]) {
			return false
		}
	}
	if !this.Result.Equal(that1.Result) {
		return false
	}
	return true
}
func (this *Doc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Doc)
	if !ok {
		that2, ok := that.(Doc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Brief != that1.Brief {
		return false
	}
	if this.Desc != that1.Desc {
		return false
	}
	if len(this.Examples) != len(that1.Examples) {
		return false
	}
	for i := range this.Examples {
		if !this.Examples[i].Equal(that1.Examples[i]) {
			return false
		}
	}
	if that1.U == nil {
		if this.U != nil {
			return false
		}
	} else if this.U == nil {
		return false
	} else if !this.U.Equal(that1.U) {
		return false
	}
	return true
}
func (this *Doc_ScalarUdfDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Doc_ScalarUdfDoc)
	if !ok {
		that2, ok := that.(Doc_ScalarUdfDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ScalarUdfDoc.Equal(that1.ScalarUdfDoc) {
		return false
	}
	return true
}
func (this *Doc_UdaDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Doc_UdaDoc)
	if !ok {
		that2, ok := that.(Doc_UdaDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.UdaDoc.Equal(that1.UdaDoc) {
		return false
	}
	return true
}
func (this *Docs) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Docs)
	if !ok {
		that2, ok := that.(Docs)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Udf) != len(that1.Udf) {
		return false
	}
	for i := range this.Udf {
		if !this.Udf[i].Equal(that1.Udf[i]) {
			return false
		}
	}
	return true
}
func (this *UDASpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&udfspb.UDASpec{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "InitArgTypes: "+fmt.Sprintf("%#v", this.InitArgTypes)+",\n")
	s = append(s, "UpdateArgTypes: "+fmt.Sprintf("%#v", this.UpdateArgTypes)+",\n")
	s = append(s, "FinalizeType: "+fmt.Sprintf("%#v", this.FinalizeType)+",\n")
	s = append(s, "SupportsPartial: "+fmt.Sprintf("%#v", this.SupportsPartial)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ScalarUDFSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&udfspb.ScalarUDFSpec{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "InitArgTypes: "+fmt.Sprintf("%#v", this.InitArgTypes)+",\n")
	s = append(s, "ExecArgTypes: "+fmt.Sprintf("%#v", this.ExecArgTypes)+",\n")
	s = append(s, "ReturnType: "+fmt.Sprintf("%#v", this.ReturnType)+",\n")
	s = append(s, "Executor: "+fmt.Sprintf("%#v", this.Executor)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UDFInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&udfspb.UDFInfo{")
	if this.Udas != nil {
		s = append(s, "Udas: "+fmt.Sprintf("%#v", this.Udas)+",\n")
	}
	if this.ScalarUdfs != nil {
		s = append(s, "ScalarUdfs: "+fmt.Sprintf("%#v", this.ScalarUdfs)+",\n")
	}
	if this.Udtfs != nil {
		s = append(s, "Udtfs: "+fmt.Sprintf("%#v", this.Udtfs)+",\n")
	}
	if this.SemanticTypeRules != nil {
		s = append(s, "SemanticTypeRules: "+fmt.Sprintf("%#v", this.SemanticTypeRules)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UDTFSourceSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&udfspb.UDTFSourceSpec{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.Args != nil {
		s = append(s, "Args: "+fmt.Sprintf("%#v", this.Args)+",\n")
	}
	s = append(s, "Executor: "+fmt.Sprintf("%#v", this.Executor)+",\n")
	if this.Relation != nil {
		s = append(s, "Relation: "+fmt.Sprintf("%#v", this.Relation)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UDTFSourceSpec_Arg) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&udfspb.UDTFSourceSpec_Arg{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ArgType: "+fmt.Sprintf("%#v", this.ArgType)+",\n")
	s = append(s, "SemanticType: "+fmt.Sprintf("%#v", this.SemanticType)+",\n")
	if this.DefaultValue != nil {
		s = append(s, "DefaultValue: "+fmt.Sprintf("%#v", this.DefaultValue)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SemanticInferenceRule) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&udfspb.SemanticInferenceRule{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "UdfExecType: "+fmt.Sprintf("%#v", this.UdfExecType)+",\n")
	s = append(s, "InitArgTypes: "+fmt.Sprintf("%#v", this.InitArgTypes)+",\n")
	s = append(s, "UpdateArgTypes: "+fmt.Sprintf("%#v", this.UpdateArgTypes)+",\n")
	s = append(s, "ExecArgTypes: "+fmt.Sprintf("%#v", this.ExecArgTypes)+",\n")
	s = append(s, "OutputType: "+fmt.Sprintf("%#v", this.OutputType)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *IdentDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&udfspb.IdentDoc{")
	s = append(s, "Ident: "+fmt.Sprintf("%#v", this.Ident)+",\n")
	s = append(s, "Desc: "+fmt.Sprintf("%#v", this.Desc)+",\n")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ScalarDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&udfspb.ScalarDoc{")
	if this.Args != nil {
		s = append(s, "Args: "+fmt.Sprintf("%#v", this.Args)+",\n")
	}
	if this.Retval != nil {
		s = append(s, "Retval: "+fmt.Sprintf("%#v", this.Retval)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExampleDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&udfspb.ExampleDoc{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UDADoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&udfspb.UDADoc{")
	if this.UpdateArgs != nil {
		s = append(s, "UpdateArgs: "+fmt.Sprintf("%#v", this.UpdateArgs)+",\n")
	}
	if this.Result != nil {
		s = append(s, "Result: "+fmt.Sprintf("%#v", this.Result)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Doc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&udfspb.Doc{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Brief: "+fmt.Sprintf("%#v", this.Brief)+",\n")
	s = append(s, "Desc: "+fmt.Sprintf("%#v", this.Desc)+",\n")
	if this.Examples != nil {
		s = append(s, "Examples: "+fmt.Sprintf("%#v", this.Examples)+",\n")
	}
	if this.U != nil {
		s = append(s, "U: "+fmt.Sprintf("%#v", this.U)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Doc_ScalarUdfDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&udfspb.Doc_ScalarUdfDoc{` +
		`ScalarUdfDoc:` + fmt.Sprintf("%#v", this.ScalarUdfDoc) + `}`}, ", ")
	return s
}
func (this *Doc_UdaDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&udfspb.Doc_UdaDoc{` +
		`UdaDoc:` + fmt.Sprintf("%#v", this.UdaDoc) + `}`}, ", ")
	return s
}
func (this *Docs) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&udfspb.Docs{")
	if this.Udf != nil {
		s = append(s, "Udf: "+fmt.Sprintf("%#v", this.Udf)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringUdfs(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *UDASpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UDASpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UDASpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SupportsPartial {
		i--
		if m.SupportsPartial {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.FinalizeType != 0 {
		i = encodeVarintUdfs(dAtA, i, uint64(m.FinalizeType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.UpdateArgTypes) > 0 {
		dAtA2 := make([]byte, len(m.UpdateArgTypes)*10)
		var j1 int
		for _, num := range m.UpdateArgTypes {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintUdfs(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.InitArgTypes) > 0 {
		dAtA4 := make([]byte, len(m.InitArgTypes)*10)
		var j3 int
		for _, num := range m.InitArgTypes {
			for num >= 1<<7 {
				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j3++
			}
			dAtA4[j3] = uint8(num)
			j3++
		}
		i -= j3
		copy(dAtA[i:], dAtA4[:j3])
		i = encodeVarintUdfs(dAtA, i, uint64(j3))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ScalarUDFSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ScalarUDFSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScalarUDFSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Executor != 0 {
		i = encodeVarintUdfs(dAtA, i, uint64(m.Executor))
		i--
		dAtA[i] = 0x28
	}
	if m.ReturnType != 0 {
		i = encodeVarintUdfs(dAtA, i, uint64(m.ReturnType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ExecArgTypes) > 0 {
		dAtA6 := make([]byte, len(m.ExecArgTypes)*10)
		var j5 int
		for _, num := range m.ExecArgTypes {
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		i -= j5
		copy(dAtA[i:], dAtA6[:j5])
		i = encodeVarintUdfs(dAtA, i, uint64(j5))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.InitArgTypes) > 0 {
		dAtA8 := make([]byte, len(m.InitArgTypes)*10)
		var j7 int
		for _, num := range m.InitArgTypes {
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA8[:j7])
		i = encodeVarintUdfs(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UDFInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UDFInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UDFInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SemanticTypeRules) > 0 {
		for iNdEx := len(m.SemanticTypeRules) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SemanticTypeRules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintUdfs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Udtfs) > 0 {
		for iNdEx := len(m.Udtfs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Udtfs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintUdfs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.ScalarUdfs) > 0 {
		for iNdEx := len(m.ScalarUdfs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ScalarUdfs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintUdfs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Udas) > 0 {
		for iNdEx := len(m.Udas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Udas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintUdfs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *UDTFSourceSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UDTFSourceSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UDTFSourceSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUdfs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Executor != 0 {
		i = encodeVarintUdfs(dAtA, i, uint64(m.Executor))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintUdfs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UDTFSourceSpec_Arg) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UDTFSourceSpec_Arg) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UDTFSourceSpec_Arg) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DefaultValue != nil {
		{
			size, err := m.DefaultValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUdfs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.SemanticType != 0 {
		i = encodeVarintUdfs(dAtA, i, uint64(m.SemanticType))
		i--
		dAtA[i] = 0x18
	}
	if m.ArgType != 0 {
		i = encodeVarintUdfs(dAtA, i, uint64(m.ArgType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SemanticInferenceRule) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SemanticInferenceRule) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SemanticInferenceRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OutputType != 0 {
		i = encodeVarintUdfs(dAtA, i, uint64(m.OutputType))
		i--
		dAtA[i] = 0x30
	}
	if len(m.ExecArgTypes) > 0 {
		dAtA12 := make([]byte, len(m.ExecArgTypes)*10)
		var j11 int
		for _, num := range m.ExecArgTypes {
			for num >= 1<<7 {
				dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j11++
			}
			dAtA12[j11] = uint8(num)
			j11++
		}
		i -= j11
		copy(dAtA[i:], dAtA12[:j11])
		i = encodeVarintUdfs(dAtA, i, uint64(j11))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.UpdateArgTypes) > 0 {
		dAtA14 := make([]byte, len(m.UpdateArgTypes)*10)
		var j13 int
		for _, num := range m.UpdateArgTypes {
			for num >= 1<<7 {
				dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j13++
			}
			dAtA14[j13] = uint8(num)
			j13++
		}
		i -= j13
		copy(dAtA[i:], dAtA14[:j13])
		i = encodeVarintUdfs(dAtA, i, uint64(j13))
		i--
		dAtA[i] = 0x22
	}
	if len(m.InitArgTypes) > 0 {
		dAtA16 := make([]byte, len(m.InitArgTypes)*10)
		var j15 int
		for _, num := range m.InitArgTypes {
			for num >= 1<<7 {
				dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j15++
			}
			dAtA16[j15] = uint8(num)
			j15++
		}
		i -= j15
		copy(dAtA[i:], dAtA16[:j15])
		i = encodeVarintUdfs(dAtA, i, uint64(j15))
		i--
		dAtA[i] = 0x1a
	}
	if m.UdfExecType != 0 {
		i = encodeVarintUdfs(dAtA, i, uint64(m.UdfExecType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IdentDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IdentDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IdentDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintUdfs(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Desc) > 0 {
		i -= len(m.Desc)
		copy(dAtA[i:], m.Desc)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Desc)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Ident) > 0 {
		i -= len(m.Ident)
		copy(dAtA[i:], m.Ident)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Ident)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ScalarDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ScalarDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScalarDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Retval != nil {
		{
			size, err := m.Retval.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUdfs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintUdfs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ExampleDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExampleDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExampleDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UDADoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UDADoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UDADoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUdfs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.UpdateArgs) > 0 {
		for iNdEx := len(m.UpdateArgs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UpdateArgs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintUdfs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Doc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Doc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Doc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.U != nil {
		{
			size := m.U.Size()
			i -= size
			if _, err := m.U.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Examples) > 0 {
		for iNdEx := len(m.Examples) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Examples[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintUdfs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Desc) > 0 {
		i -= len(m.Desc)
		copy(dAtA[i:], m.Desc)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Desc)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Brief) > 0 {
		i -= len(m.Brief)
		copy(dAtA[i:], m.Brief)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Brief)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintUdfs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Doc_ScalarUdfDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Doc_ScalarUdfDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ScalarUdfDoc != nil {
		{
			size, err := m.ScalarUdfDoc.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUdfs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *Doc_UdaDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Doc_UdaDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.UdaDoc != nil {
		{
			size, err := m.UdaDoc.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUdfs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *Docs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Docs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Docs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Udf) > 0 {
		for iNdEx := len(m.Udf) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Udf[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintUdfs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintUdfs(dAtA []byte, offset int, v uint64) int {
	offset -= sovUdfs(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *UDASpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	if len(m.InitArgTypes) > 0 {
		l = 0
		for _, e := range m.InitArgTypes {
			l += sovUdfs(uint64(e))
		}
		n += 1 + sovUdfs(uint64(l)) + l
	}
	if len(m.UpdateArgTypes) > 0 {
		l = 0
		for _, e := range m.UpdateArgTypes {
			l += sovUdfs(uint64(e))
		}
		n += 1 + sovUdfs(uint64(l)) + l
	}
	if m.FinalizeType != 0 {
		n += 1 + sovUdfs(uint64(m.FinalizeType))
	}
	if m.SupportsPartial {
		n += 2
	}
	return n
}

func (m *ScalarUDFSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	if len(m.InitArgTypes) > 0 {
		l = 0
		for _, e := range m.InitArgTypes {
			l += sovUdfs(uint64(e))
		}
		n += 1 + sovUdfs(uint64(l)) + l
	}
	if len(m.ExecArgTypes) > 0 {
		l = 0
		for _, e := range m.ExecArgTypes {
			l += sovUdfs(uint64(e))
		}
		n += 1 + sovUdfs(uint64(l)) + l
	}
	if m.ReturnType != 0 {
		n += 1 + sovUdfs(uint64(m.ReturnType))
	}
	if m.Executor != 0 {
		n += 1 + sovUdfs(uint64(m.Executor))
	}
	return n
}

func (m *UDFInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Udas) > 0 {
		for _, e := range m.Udas {
			l = e.Size()
			n += 1 + l + sovUdfs(uint64(l))
		}
	}
	if len(m.ScalarUdfs) > 0 {
		for _, e := range m.ScalarUdfs {
			l = e.Size()
			n += 1 + l + sovUdfs(uint64(l))
		}
	}
	if len(m.Udtfs) > 0 {
		for _, e := range m.Udtfs {
			l = e.Size()
			n += 1 + l + sovUdfs(uint64(l))
		}
	}
	if len(m.SemanticTypeRules) > 0 {
		for _, e := range m.SemanticTypeRules {
			l = e.Size()
			n += 1 + l + sovUdfs(uint64(l))
		}
	}
	return n
}

func (m *UDTFSourceSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovUdfs(uint64(l))
		}
	}
	if m.Executor != 0 {
		n += 1 + sovUdfs(uint64(m.Executor))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovUdfs(uint64(l))
	}
	return n
}

func (m *UDTFSourceSpec_Arg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	if m.ArgType != 0 {
		n += 1 + sovUdfs(uint64(m.ArgType))
	}
	if m.SemanticType != 0 {
		n += 1 + sovUdfs(uint64(m.SemanticType))
	}
	if m.DefaultValue != nil {
		l = m.DefaultValue.Size()
		n += 1 + l + sovUdfs(uint64(l))
	}
	return n
}

func (m *SemanticInferenceRule) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	if m.UdfExecType != 0 {
		n += 1 + sovUdfs(uint64(m.UdfExecType))
	}
	if len(m.InitArgTypes) > 0 {
		l = 0
		for _, e := range m.InitArgTypes {
			l += sovUdfs(uint64(e))
		}
		n += 1 + sovUdfs(uint64(l)) + l
	}
	if len(m.UpdateArgTypes) > 0 {
		l = 0
		for _, e := range m.UpdateArgTypes {
			l += sovUdfs(uint64(e))
		}
		n += 1 + sovUdfs(uint64(l)) + l
	}
	if len(m.ExecArgTypes) > 0 {
		l = 0
		for _, e := range m.ExecArgTypes {
			l += sovUdfs(uint64(e))
		}
		n += 1 + sovUdfs(uint64(l)) + l
	}
	if m.OutputType != 0 {
		n += 1 + sovUdfs(uint64(m.OutputType))
	}
	return n
}

func (m *IdentDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Ident)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	l = len(m.Desc)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovUdfs(uint64(m.Type))
	}
	return n
}

func (m *ScalarDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovUdfs(uint64(l))
		}
	}
	if m.Retval != nil {
		l = m.Retval.Size()
		n += 1 + l + sovUdfs(uint64(l))
	}
	return n
}

func (m *ExampleDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	return n
}

func (m *UDADoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.UpdateArgs) > 0 {
		for _, e := range m.UpdateArgs {
			l = e.Size()
			n += 1 + l + sovUdfs(uint64(l))
		}
	}
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovUdfs(uint64(l))
	}
	return n
}

func (m *Doc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	l = len(m.Brief)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	l = len(m.Desc)
	if l > 0 {
		n += 1 + l + sovUdfs(uint64(l))
	}
	if len(m.Examples) > 0 {
		for _, e := range m.Examples {
			l = e.Size()
			n += 1 + l + sovUdfs(uint64(l))
		}
	}
	if m.U != nil {
		n += m.U.Size()
	}
	return n
}

func (m *Doc_ScalarUdfDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScalarUdfDoc != nil {
		l = m.ScalarUdfDoc.Size()
		n += 1 + l + sovUdfs(uint64(l))
	}
	return n
}
func (m *Doc_UdaDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UdaDoc != nil {
		l = m.UdaDoc.Size()
		n += 1 + l + sovUdfs(uint64(l))
	}
	return n
}
func (m *Docs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Udf) > 0 {
		for _, e := range m.Udf {
			l = e.Size()
			n += 1 + l + sovUdfs(uint64(l))
		}
	}
	return n
}

func sovUdfs(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozUdfs(x uint64) (n int) {
	return sovUdfs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *UDASpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UDASpec{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`InitArgTypes:` + fmt.Sprintf("%v", this.InitArgTypes) + `,`,
		`UpdateArgTypes:` + fmt.Sprintf("%v", this.UpdateArgTypes) + `,`,
		`FinalizeType:` + fmt.Sprintf("%v", this.FinalizeType) + `,`,
		`SupportsPartial:` + fmt.Sprintf("%v", this.SupportsPartial) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScalarUDFSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ScalarUDFSpec{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`InitArgTypes:` + fmt.Sprintf("%v", this.InitArgTypes) + `,`,
		`ExecArgTypes:` + fmt.Sprintf("%v", this.ExecArgTypes) + `,`,
		`ReturnType:` + fmt.Sprintf("%v", this.ReturnType) + `,`,
		`Executor:` + fmt.Sprintf("%v", this.Executor) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UDFInfo) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForUdas := "[]*UDASpec{"
	for _, f := range this.Udas {
		repeatedStringForUdas += strings.Replace(f.String(), "UDASpec", "UDASpec", 1) + ","
	}
	repeatedStringForUdas += "}"
	repeatedStringForScalarUdfs := "[]*ScalarUDFSpec{"
	for _, f := range this.ScalarUdfs {
		repeatedStringForScalarUdfs += strings.Replace(f.String(), "ScalarUDFSpec", "ScalarUDFSpec", 1) + ","
	}
	repeatedStringForScalarUdfs += "}"
	repeatedStringForUdtfs := "[]*UDTFSourceSpec{"
	for _, f := range this.Udtfs {
		repeatedStringForUdtfs += strings.Replace(f.String(), "UDTFSourceSpec", "UDTFSourceSpec", 1) + ","
	}
	repeatedStringForUdtfs += "}"
	repeatedStringForSemanticTypeRules := "[]*SemanticInferenceRule{"
	for _, f := range this.SemanticTypeRules {
		repeatedStringForSemanticTypeRules += strings.Replace(f.String(), "SemanticInferenceRule", "SemanticInferenceRule", 1) + ","
	}
	repeatedStringForSemanticTypeRules += "}"
	s := strings.Join([]string{`&UDFInfo{`,
		`Udas:` + repeatedStringForUdas + `,`,
		`ScalarUdfs:` + repeatedStringForScalarUdfs + `,`,
		`Udtfs:` + repeatedStringForUdtfs + `,`,
		`SemanticTypeRules:` + repeatedStringForSemanticTypeRules + `,`,
		`}`,
	}, "")
	return s
}
func (this *UDTFSourceSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForArgs := "[]*UDTFSourceSpec_Arg{"
	for _, f := range this.Args {
		repeatedStringForArgs += strings.Replace(fmt.Sprintf("%v", f), "UDTFSourceSpec_Arg", "UDTFSourceSpec_Arg", 1) + ","
	}
	repeatedStringForArgs += "}"
	s := strings.Join([]string{`&UDTFSourceSpec{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Args:` + repeatedStringForArgs + `,`,
		`Executor:` + fmt.Sprintf("%v", this.Executor) + `,`,
		`Relation:` + strings.Replace(fmt.Sprintf("%v", this.Relation), "Relation", "schemapb.Relation", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UDTFSourceSpec_Arg) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UDTFSourceSpec_Arg{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ArgType:` + fmt.Sprintf("%v", this.ArgType) + `,`,
		`SemanticType:` + fmt.Sprintf("%v", this.SemanticType) + `,`,
		`DefaultValue:` + strings.Replace(fmt.Sprintf("%v", this.DefaultValue), "ScalarValue", "planpb.ScalarValue", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SemanticInferenceRule) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SemanticInferenceRule{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`UdfExecType:` + fmt.Sprintf("%v", this.UdfExecType) + `,`,
		`InitArgTypes:` + fmt.Sprintf("%v", this.InitArgTypes) + `,`,
		`UpdateArgTypes:` + fmt.Sprintf("%v", this.UpdateArgTypes) + `,`,
		`ExecArgTypes:` + fmt.Sprintf("%v", this.ExecArgTypes) + `,`,
		`OutputType:` + fmt.Sprintf("%v", this.OutputType) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IdentDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IdentDoc{`,
		`Ident:` + fmt.Sprintf("%v", this.Ident) + `,`,
		`Desc:` + fmt.Sprintf("%v", this.Desc) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScalarDoc) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForArgs := "[]*IdentDoc{"
	for _, f := range this.Args {
		repeatedStringForArgs += strings.Replace(f.String(), "IdentDoc", "IdentDoc", 1) + ","
	}
	repeatedStringForArgs += "}"
	s := strings.Join([]string{`&ScalarDoc{`,
		`Args:` + repeatedStringForArgs + `,`,
		`Retval:` + strings.Replace(this.Retval.String(), "IdentDoc", "IdentDoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExampleDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExampleDoc{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UDADoc) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForUpdateArgs := "[]*IdentDoc{"
	for _, f := range this.UpdateArgs {
		repeatedStringForUpdateArgs += strings.Replace(f.String(), "IdentDoc", "IdentDoc", 1) + ","
	}
	repeatedStringForUpdateArgs += "}"
	s := strings.Join([]string{`&UDADoc{`,
		`UpdateArgs:` + repeatedStringForUpdateArgs + `,`,
		`Result:` + strings.Replace(this.Result.String(), "IdentDoc", "IdentDoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Doc) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForExamples := "[]*ExampleDoc{"
	for _, f := range this.Examples {
		repeatedStringForExamples += strings.Replace(f.String(), "ExampleDoc", "ExampleDoc", 1) + ","
	}
	repeatedStringForExamples += "}"
	s := strings.Join([]string{`&Doc{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Brief:` + fmt.Sprintf("%v", this.Brief) + `,`,
		`Desc:` + fmt.Sprintf("%v", this.Desc) + `,`,
		`Examples:` + repeatedStringForExamples + `,`,
		`U:` + fmt.Sprintf("%v", this.U) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Doc_ScalarUdfDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Doc_ScalarUdfDoc{`,
		`ScalarUdfDoc:` + strings.Replace(fmt.Sprintf("%v", this.ScalarUdfDoc), "ScalarDoc", "ScalarDoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Doc_UdaDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Doc_UdaDoc{`,
		`UdaDoc:` + strings.Replace(fmt.Sprintf("%v", this.UdaDoc), "UDADoc", "UDADoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Docs) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForUdf := "[]*Doc{"
	for _, f := range this.Udf {
		repeatedStringForUdf += strings.Replace(f.String(), "Doc", "Doc", 1) + ","
	}
	repeatedStringForUdf += "}"
	s := strings.Join([]string{`&Docs{`,
		`Udf:` + repeatedStringForUdf + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringUdfs(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *UDASpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UDASpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UDASpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v typespb.DataType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= typespb.DataType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.InitArgTypes = append(m.InitArgTypes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthUdfs
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthUdfs
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.InitArgTypes) == 0 {
					m.InitArgTypes = make([]typespb.DataType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v typespb.DataType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowUdfs
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= typespb.DataType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.InitArgTypes = append(m.InitArgTypes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field InitArgTypes", wireType)
			}
		case 3:
			if wireType == 0 {
				var v typespb.DataType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= typespb.DataType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.UpdateArgTypes = append(m.UpdateArgTypes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthUdfs
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthUdfs
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.UpdateArgTypes) == 0 {
					m.UpdateArgTypes = make([]typespb.DataType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v typespb.DataType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowUdfs
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= typespb.DataType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.UpdateArgTypes = append(m.UpdateArgTypes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateArgTypes", wireType)
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinalizeType", wireType)
			}
			m.FinalizeType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FinalizeType |= typespb.DataType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SupportsPartial", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SupportsPartial = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ScalarUDFSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ScalarUDFSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScalarUDFSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v typespb.DataType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= typespb.DataType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.InitArgTypes = append(m.InitArgTypes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthUdfs
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthUdfs
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.InitArgTypes) == 0 {
					m.InitArgTypes = make([]typespb.DataType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v typespb.DataType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowUdfs
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= typespb.DataType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.InitArgTypes = append(m.InitArgTypes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field InitArgTypes", wireType)
			}
		case 3:
			if wireType == 0 {
				var v typespb.DataType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= typespb.DataType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ExecArgTypes = append(m.ExecArgTypes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthUdfs
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthUdfs
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.ExecArgTypes) == 0 {
					m.ExecArgTypes = make([]typespb.DataType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v typespb.DataType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowUdfs
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= typespb.DataType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ExecArgTypes = append(m.ExecArgTypes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecArgTypes", wireType)
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReturnType", wireType)
			}
			m.ReturnType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReturnType |= typespb.DataType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Executor", wireType)
			}
			m.Executor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Executor |= UDFSourceExecutor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UDFInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UDFInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UDFInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Udas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Udas = append(m.Udas, &UDASpec{})
			if err := m.Udas[len(m.Udas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScalarUdfs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScalarUdfs = append(m.ScalarUdfs, &ScalarUDFSpec{})
			if err := m.ScalarUdfs[len(m.ScalarUdfs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Udtfs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Udtfs = append(m.Udtfs, &UDTFSourceSpec{})
			if err := m.Udtfs[len(m.Udtfs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SemanticTypeRules", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SemanticTypeRules = append(m.SemanticTypeRules, &SemanticInferenceRule{})
			if err := m.SemanticTypeRules[len(m.SemanticTypeRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UDTFSourceSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UDTFSourceSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UDTFSourceSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, &UDTFSourceSpec_Arg{})
			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Executor", wireType)
			}
			m.Executor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Executor |= UDTFSourceExecutor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Relation == nil {
				m.Relation = &schemapb.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UDTFSourceSpec_Arg) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Arg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Arg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArgType", wireType)
			}
			m.ArgType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ArgType |= typespb.DataType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SemanticType", wireType)
			}
			m.SemanticType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SemanticType |= typespb.SemanticType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DefaultValue == nil {
				m.DefaultValue = &planpb.ScalarValue{}
			}
			if err := m.DefaultValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SemanticInferenceRule) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SemanticInferenceRule: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SemanticInferenceRule: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UdfExecType", wireType)
			}
			m.UdfExecType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UdfExecType |= UDFExecType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType == 0 {
				var v typespb.SemanticType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= typespb.SemanticType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.InitArgTypes = append(m.InitArgTypes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthUdfs
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthUdfs
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.InitArgTypes) == 0 {
					m.InitArgTypes = make([]typespb.SemanticType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v typespb.SemanticType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowUdfs
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= typespb.SemanticType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.InitArgTypes = append(m.InitArgTypes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field InitArgTypes", wireType)
			}
		case 4:
			if wireType == 0 {
				var v typespb.SemanticType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= typespb.SemanticType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.UpdateArgTypes = append(m.UpdateArgTypes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthUdfs
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthUdfs
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.UpdateArgTypes) == 0 {
					m.UpdateArgTypes = make([]typespb.SemanticType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v typespb.SemanticType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowUdfs
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= typespb.SemanticType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.UpdateArgTypes = append(m.UpdateArgTypes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateArgTypes", wireType)
			}
		case 5:
			if wireType == 0 {
				var v typespb.SemanticType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= typespb.SemanticType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ExecArgTypes = append(m.ExecArgTypes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUdfs
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthUdfs
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthUdfs
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.ExecArgTypes) == 0 {
					m.ExecArgTypes = make([]typespb.SemanticType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v typespb.SemanticType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowUdfs
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= typespb.SemanticType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ExecArgTypes = append(m.ExecArgTypes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecArgTypes", wireType)
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputType", wireType)
			}
			m.OutputType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OutputType |= typespb.SemanticType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IdentDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IdentDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IdentDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ident", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ident = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Desc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= typespb.DataType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ScalarDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ScalarDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScalarDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, &IdentDoc{})
			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Retval", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Retval == nil {
				m.Retval = &IdentDoc{}
			}
			if err := m.Retval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExampleDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExampleDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExampleDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UDADoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UDADoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UDADoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateArgs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpdateArgs = append(m.UpdateArgs, &IdentDoc{})
			if err := m.UpdateArgs[len(m.UpdateArgs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &IdentDoc{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Doc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Doc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Doc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Brief", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Brief = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Desc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Examples", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Examples = append(m.Examples, &ExampleDoc{})
			if err := m.Examples[len(m.Examples)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScalarUdfDoc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ScalarDoc{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.U = &Doc_ScalarUdfDoc{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UdaDoc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UDADoc{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.U = &Doc_UdaDoc{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Docs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Docs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Docs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Udf", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUdfs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUdfs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Udf = append(m.Udf, &Doc{})
			if err := m.Udf[len(m.Udf)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUdfs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUdfs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipUdfs(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowUdfs
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowUdfs
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthUdfs
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupUdfs
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthUdfs
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthUdfs        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowUdfs          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupUdfs = fmt.Errorf("proto: unexpected end of group")
)
